If we relax the
smoothness requirement, then we can use
interpolation functions. They're not
necessarily continues. For instance, we could
decide given this set of data points to just keep
the value of the continuous time interpolator constant between
interpolation intervals and we would get
a staircase function like this. Now, this is of
course discontinuous. We have jumps between
interpolation intervals. But the advantage of this interpolation strategy
is that it can be performed using an interpolation
machine that does not depend on the length
of the dataset. This type of
interpolation is also known as Kernel-based
interpolation, because for each data point, we put in place a kernel
namely a local function of a given shape that is centered around
the interpolation point, and then we sum all
of these together. In the case of this type
of interpolation, which is called the
zero-order interpolation, the kernel is simply
a rectangular function like so. Mathematically, we can describe the continuous time signal
with this expression here. Namely, for each value of t, we compute the closest
integer and we take the discrete time sample
indexed by that integer. But it's more instructive to look at the
continuous time signal as this mixed domain convolution. I call it mixed domain because you have a discrete time signal here represented by X of n and a continuous
time signal here, which is the kernel which
is this rectangular shape. What we are doing here is
building linear combination of shifted rectangles
and each rectangle will have a height which is equal
to the discrete data point associated to the interval
subtended by the rect. So the interpolation kernel is a simple rectangular
function, namely, it's a constant over
an interval and therefore a zero-order
polynomial, and that's why
the interpolator is called a zero-order hold. The support of
the interpolation is, one, it goes from minus one half to one half and the interpolation that is not even continuous. To see how this works, let's take our usual
set of points. Now, we place
a rectangular kernel at each discrete time point, and when we sum
them all together, we obtain the staircase function that we have seen
at the beginning. Notice that this now does not depend on the length
of the dataset. We could apply this to an arbitrary large number of points without
change in the strategy. As a matter of fact, we can do this in real time with a delay of
only half the sample. We can increase the smoothness
of the result still within the context of
Kernel-based interpolators by using a first-order
interpolator. A first order
interpolator connects the dots between point
with a straight line, and these two can be
obtained by using a kernel. The kernel in this case is a first-order kernel that has
a triangular shape like so. It goes from minus one to
one and goes to one here. The support of
the interpolation now is two and the interpolation
is continuous, but its first
derivative, it's not. We have sharp changes of
direction in the function. How does this work in practice? So same dataset as before, and for each data point, we place a first-order kernel. So this triangular
function like so, and when you sum
all these triangles together, you get the connected dot line
that we saw before. Notice that now we need two points to compute the value of the interpolation
function at each instant t. This is reflected by the fact
that the support of the first order
interpolator is two and not one like in
the zero order interpolator. So still this system could
be implemented in real-time, but the delay now
increases to one-sample. Can we increase the smoothness of the interpolation function more? Yes we can. We can move to
a third-order interpolator. We skip the second-order
interpolator because it's not symmetric
around the center point. So we only use
odd order interpolators. The principle is the same. We have a mixed domain
convolution to build our continuous time signal and the kernel is a cubic kernel. There is a plane by splicing together
two cubic polynomials. The details are not important. What's important is
that interpolator support is four now. So we need four points to compute each value of the
continuous time signal, and the interpolation is continuous up to the
second derivative. In practice, this works like so, same set of data points, and we place this cubic kernel
that looks like this. Notice that the cubic kernel has indeed
interpolation property, namely is equal to one in
zero and it's equal to zero at all other integer values
of the argument. When we sum all these
curves together, we obtain something that
clearly appears very smooth because it's moved up
to the second derivative. In general, a local
interpolation scheme will always use this kind of
mixed domain convolution. So you're building a continuous
time signal by summing together delayed copies
of the same kernel and the only properties
that are required for this to work
is that the kernel is equal to one and
zero and is equal to zero for t non-zero integer. In reality, when T_s
is not equal to one, we will require
the interpolator to be equal to zero for
all multiples of T_s for n different from
zero and n integer. So let's review the kernels
we have seen so far. Zero-order is erect
with support one. First-order is a triangle
with support two, and third order is a cubic
function with support four. The key property of the local interpolation
is that it will work independently of the size
of the dataset and the drawback is that
it lacks smoothness. So now the question is, can we have the best
of both worlds, namely at least in theory? Can we have a Kernel-based
interpolator that also yields a maximally
smooth function? The answer is yes,
and it will use a kernel that is equal
to the sinc function.